from typing import Optional, Union, List


class AlgoParamDefine:
    """
    算法参数定义类，用于描述算法参数的详细信息

    参数:
    - key: 参数的唯一标识符
    - display_name: 参数在界面上显示的名称
    - is_required: 参数是否为必填项
    - regex_pattern: 参数值的正则表达式模式（可选）
    - data_type: 参数的数据类型，1. 字符串， 2 数字 3. 布尔（建议优先数字），4，数组，[1,2,3] ，5， 区域，保持现有的区域
    - max_value: 参数值的最大限制（可选）
    - min_value: 参数值的最小限制（可选）
    - options: 参数值的可选列表-下拉框（可选）
    - ui_render_type: 参数在界面渲染时的类型，默认为输入框（可选）
    """
    def __init__(
        self,
        key: str,
        display_name: str,
        is_required: bool,
        default_value=None,
        regex_pattern: Optional[str] = None,
        data_type: Optional[Union[int, float]] = 1,
        max_value: Optional[Union[int, float]] = None,
        min_value: Optional[Union[int, float]] = None,
        options: Optional[List[str]] = None,
        ui_render_type: Optional[str] = "input"
    ):
        self.key = key
        self.display_name = display_name
        self.default_value = default_value
        self.is_required = is_required
        self.regex_pattern = regex_pattern
        self.data_type = data_type
        self.max_value = max_value
        self.min_value = min_value
        self.options = options
        self.ui_render_type = ui_render_type

    @classmethod
    def from_dict(cls, data: dict):
        """
        从字典数据构造算法参数定义对象

        参数:
        - data: 包含算法参数定义信息的字典

        返回:
        - AlgoParamDefine对象
        """
        return cls(
            key=data.get("key"),
            display_name=data.get("display_name"),
            is_required=data.get("is_required"),
            default_value=data.get("default_value"),
            regex_pattern=data.get("regex_pattern"),
            data_type=data.get("data_type"),
            max_value=data.get("max_value"),
            min_value=data.get("min_value"),
            options=data.get("options"),
            ui_render_type=data.get("ui_render_type")
        )

    def to_dict(self):
        """
        将算法参数定义对象转换为字典格式

        返回:
        - 包含算法参数定义信息的字典
        """
        return {
            "key": self.key,
            "display_name": self.display_name,
            "is_required": self.is_required,
            "default_value":self.default_value,
            "regex_pattern": self.regex_pattern,
            "data_type": self.data_type,
            "max_value": self.max_value,
            "min_value": self.min_value,
            "options": self.options,
            "ui_render_type": self.ui_render_type
        }

class AlgoParamReq:
    """
    算法参数请求类，用于描述算法参数的实际输入值

    参数:
    - key: 参数的唯一标识符
    - value: 参数的实际输入值
    - data_type: 参数的实际数据类型，可选
    """
    def __init__(
        self,
        key: str,
        value,
        data_type: Optional[Union[int, float]] = None
    ):
        self.key = key
        self.value = value
        self.data_type = data_type

    @classmethod
    def from_dict(cls, data: dict):
        """
        从字典数据构造算法参数请求对象

        参数:
        - data: 包含算法参数请求信息的字典

        返回:
        - AlgoParamReq对象
        """
        return cls(
            key=data.get("key"),
            value=data.get("value"),
            data_type=data.get("data_type")
        )

    def to_dict(self):
        """
        将算法参数请求对象转换为字典格式

        返回:
        - 包含算法参数请求信息的字典
        """
        return {self.key:{
            "key": self.key,
            "value": self.value,
            "data_type": self.data_type
            }
        }

class AlgoResponseDefine:

    def __init__(
            self,
            type: int, # 0 标签， 1. 文本描述 2. 区域框， 3. 数字, 4.小数， 5. 百分比
            group: str,
            id:int, # 分组下的唯一值
            key: str,
            val,
            label: Optional[str] = None,
    ):
        self.type = type
        self.group = group
        self.id = id
        self.key = key
        self.val = val
        self.label = label
    def to_dict(self):
        """
        将算法参数请求对象转换为字典格式

        返回:
        - 包含算法参数请求信息的字典
        """
        return {
            "id": self.id,
            "type": self.type,
            "group": self.group,
            "key": self.key,
            "val": self.val,
            "label":self.label
        }

# 示例用法,定义了一个目标的描述

a1 = AlgoResponseDefine(type=0, group="人", id=1, key="性别", val="男",label="ffs").to_dict()
a2 = AlgoResponseDefine(type=1, group="人", id=1, key="人种", val="中国人").to_dict()
a3 = AlgoResponseDefine(type=2, group="人", id=1, key="区域", val=[[252, 508], [355, 508], [355, 756], [252, 756]]).to_dict()
a4 = AlgoResponseDefine(type=3, group="人", id=1, key="年龄", val=45).to_dict()
a5 = AlgoResponseDefine(type=5, group="人", id=1, key="置信度", val=0.4770892560482025).to_dict()
a6 = AlgoResponseDefine(type=0, group="猫咪", id=2, key="颜色", val="花色").to_dict()
a7 = AlgoResponseDefine(type=2, group="猫咪", id=1, key="区域", val=[[252, 508], [355, 508], [355, 756], [252, 756]]).to_dict()

print(a1)
#print(AlgoParamReq(key="dfd", value="dfd", data_type=1).to_dict())